package com.ruoyi.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.utils.ConvertUtil;
import com.ruoyi.system.domain.BsJingqu;
import com.ruoyi.system.domain.BsMenpiaoCategory;
import com.ruoyi.system.domain.BsMenpiaoNum;
import com.ruoyi.system.domain.BsMenpiaoTime;
import com.ruoyi.system.domain.dto.MenPiaoDto;
import com.ruoyi.system.domain.dto.MenPiaoTimeDto;
import com.ruoyi.system.domain.vo.MenPiaoNumVo;
import com.ruoyi.system.domain.vo.MenPiaoTimeVo;
import com.ruoyi.system.domain.vo.MenPiaoVo;
import com.ruoyi.system.mapper.BsMenpiaoCategoryMapper;
import com.ruoyi.system.service.BsJingquService;
import com.ruoyi.system.service.BsMenpiaoCategoryService;
import com.ruoyi.system.service.BsMenpiaoNumService;
import com.ruoyi.system.service.BsMenpiaoTimeService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 *
 */
@Service
public class BsMenpiaoCategoryServiceImpl extends ServiceImpl<BsMenpiaoCategoryMapper, BsMenpiaoCategory>
    implements BsMenpiaoCategoryService{

    @Resource
    private BsMenpiaoNumService bsMenpiaoNumService;
    @Resource
    private BsMenpiaoTimeService bsMenpiaoTimeService;
    @Resource
    private BsJingquService bsJingquService;
    /**
     * 对传入的门票信息进行保存
     * @param menPiaoVo
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean dealAndSave(MenPiaoVo menPiaoVo) {
        // 门票种类转化成实体类
        List<BsMenpiaoCategory> menpiaoCategories = ConvertUtil.sourceToTarget(menPiaoVo.getMenPiaoCategorys(), BsMenpiaoCategory.class);
        // 为种类添加上景区ID
        menpiaoCategories.forEach(x -> x.setJingquId(menPiaoVo.getJingquId()));
        List<BsMenpiaoNum> saveList = new ArrayList<>();
        // 保存种类，返回每个种类的ID，并进行下一步操作
        if (saveBatch(menpiaoCategories)){
            List<MenPiaoTimeVo> menPiaoTimes = menPiaoVo.getMenPiaoTimes();
            // 循环门票的时间段集合
            menPiaoTimes.forEach(x -> {
                BsMenpiaoTime bsMenpiaoTime = ConvertUtil.sourceToTarget(x, BsMenpiaoTime.class);
                // 设置时间段的景区ID
                bsMenpiaoTime.setJingquId(menPiaoVo.getJingquId());
                // 保存时间段并获取时间段的ID
                bsMenpiaoTimeService.save(bsMenpiaoTime);
                // 循环每个时间段门票种类的比例和数量
                for (MenPiaoNumVo menPiaoNum : x.getMenPiaoNums()) {
                    BsMenpiaoNum bsMenpiaoNum = ConvertUtil.sourceToTarget(menPiaoNum, BsMenpiaoNum.class);
                    bsMenpiaoNum.setMenpiaoTimeId(bsMenpiaoTime.getMenpiaoTimeId());
                    // 通过index索引判断所属的种类，以此来获得种类的ID
                    bsMenpiaoNum.setMenpiaoCategoryId(getCategoryIdByIndex(menpiaoCategories, menPiaoNum.getIndex()));
                    bsMenpiaoNum.setJingquId(menPiaoVo.getJingquId());
                    // 门票数量保存在集合中，后面统一插入到数据库中
                    saveList.add(bsMenpiaoNum);
                }
            });
        }
        return bsMenpiaoNumService.saveBatch(saveList);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean deleteAndSave(MenPiaoVo menPiaoVo) {
        removeByJingquId(menPiaoVo.getJingquId());
        bsMenpiaoTimeService.removeByJingquId(menPiaoVo.getJingquId());
        bsMenpiaoNumService.removeByJingquId(menPiaoVo.getJingquId());
        return dealAndSave(menPiaoVo);
    }

    public boolean removeByJingquId(Long jingquId){
        LambdaQueryWrapper<BsMenpiaoCategory> lqw = new LambdaQueryWrapper<>();
        lqw.eq(BsMenpiaoCategory::getJingquId,jingquId);
        return remove(lqw);
    }

    @Override
    public List<BsMenpiaoCategory> listByJingquId(Long jingquId) {
        LambdaQueryWrapper<BsMenpiaoCategory> lqw = new LambdaQueryWrapper<>();
        lqw.eq(BsMenpiaoCategory::getJingquId,jingquId);
        return list(lqw);
    }

    @Override
    public MenPiaoDto getInfoByJingquId(Long jingquId) {
        MenPiaoDto menPiaoDto = new MenPiaoDto();
        // 查询景区信息
        BsJingqu jingquInfo = bsJingquService.getById(jingquId);
        menPiaoDto.setJingquId(jingquInfo.getJingquId());
        menPiaoDto.setJingquName(jingquInfo.getJingquName());
        // 查询门票类型
        List<BsMenpiaoCategory> bsMenpiaoCategories = listByJingquId(jingquId);
        menPiaoDto.setMenPiaoCategorys(bsMenpiaoCategories);
        // 查询时间信息
        List<BsMenpiaoTime> bsMenpiaoTimes = bsMenpiaoTimeService.listByJingquId(jingquId);
        // 查询门票数量信息
        List<BsMenpiaoNum> bsMenpiaoNums = bsMenpiaoNumService.listByJingquId(jingquId);
        // 处理时间和数量关系，保存到集合中
        List<MenPiaoTimeDto> dtos = new ArrayList<>();
        bsMenpiaoTimes.forEach(x -> {
            MenPiaoTimeDto dto = new MenPiaoTimeDto();
            List<BsMenpiaoNum> menpiaoNums = bsMenpiaoNums.stream().filter(y -> y.getMenpiaoTimeId().equals(x.getMenpiaoTimeId())).collect(Collectors.toList());
            dto.setStartTime(x.getStartTime());
            dto.setEndTime(x.getEndTime());
            dto.setTotal(menpiaoNums.stream().mapToInt(BsMenpiaoNum::getMenpiaoNum).sum());
            dto.setMenPiaoNums(menpiaoNums);
            dtos.add(dto);
        });
        menPiaoDto.setMenPiaoTimes(dtos);
        return menPiaoDto;
    }

    /**
     * 通过门票类型的索引获得门票的主键ID
     * @param categoryList
     * @param index
     * @return
     */
    public Long getCategoryIdByIndex(List<BsMenpiaoCategory> categoryList, Integer index){
        for (BsMenpiaoCategory bsMenpiaoCategory : categoryList) {
            if (bsMenpiaoCategory.getIndex().equals(index)){
                return bsMenpiaoCategory.getMenpiaoCategoryId();
            }
        }
        return null;
    }
}




